星尘

4. Final, Native, Abstract, 接口, Comparable

发表于 更新于 分类于

Final

final: 最终的意思，是一个修饰符。

  1. 修饰类：可以修饰类，包括内部类和外部类。

    修饰类的时候表示这个类不能被继承，是个太监类，即没有子类。

  2. 修饰方法

    修饰方法的时候表示该方法可以被子类继承，但是不能被子类重写。

  3. 修饰变量：包括属性和局部变量。

    表示被修饰的变量为常量，值不能被修改。

Native

native: 原生的，内置的。

只能修饰方法，被修饰的方法说明不是 Java 语言实现的方法体，而是由 C 语言等实现的，用 C 语言等实现后，编译成 .dll 文件被 Java 调用。使用上和普通的 Java 方法没有区别，可以被正常调用，可以被重写等。

Abstract

抽象的。作用也是修饰符，只能修饰类（包括内部类和外部类）和方法。 当我们在设计父类时，发现某些方法是无法给出具体的实现，具体的实现应该在子类中实现。那么这样的方法，在父类中就可以设计为“抽象方法”，包含抽象方法的类，必须是一个“抽象类”

抽象类的特点：

  1. 抽象类不能直接 new 对象。
  2. 抽象类本来就是用来继承的，那么子类继承抽象类之后，必须实现抽象类的所有方法，否则子类也得是抽象类才行。
  3. 抽象类可以和普通类一样，拥有属性，构造器，代码块，非抽象的方法等成员，虽然抽象类不能 new 对象，但是这些可以给抽象类的子类使用。
  4. 一个类如果有抽象方法，那么这个类必须是抽象类。相反，如果一个类是抽象类，那么不一定有抽象方法。这么做的目的是不希望使用者拥有抽象类的对象，希望你创建其子类的对象。

Abstract 和各类修饰符的混合使用情况：

  1. static 和 abstract 不能同时修饰方法，因为被 static 修饰的方法不能被重写，而被 abstract 修饰的方法需要被重写。
  2. final 和 abstract 不能同时修饰方法，final 是表示不能被重写，而 abstract 修饰的方法需要被重写。
  3. native 和 abstract 不能同时修饰方法，native 是表示方法是由 c 语言实现的，abstract 表示无方法体，由子类实现。
  4. private 和 abstract 不能同时修饰方法，因为 private 的方法在子类中不可见，无法重写。
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
public class TestAbstrace {
	public static void main(String[] args){
		Circle circle = new Circle();
		circle.getArea();
	}
}

abstract class Graphic{
	private String name;
	abstract double getArea();

	public Graphic(String name) {
		this.name = name;
	}

	public Graphic() {
	}

	public String getName() {
		return name;
	}

	public void setName(String name) {
		this.name = name;
	}
}

class Circle extends Graphic{
	public Circle(String name) {
		super(name);
	}

	public Circle() {
	}

	/**
	 * 必须实现抽象类的所有抽象方法
	 * @return
	 */
	@Override
	double getArea() {
		return 0;
	}
}

abstract class Triangle extends Graphic{
	public Triangle(String name) {
		super(name);
	}
	/**
	 * 或者子类成为抽象类
	 */
}

修饰符总结

权限修饰符

共有，public，protected，缺省，private。

public 和缺省可以修饰：类（包括内部类和外部类），方法，属性，构造器。

protected 和 private可以修饰：内部类，方法，属性，构造器。

static

可以修饰属性，内部类，方法，代码块

final

可以修饰类（包括内部类和外部类），方法，属性，局部变量

native

只能修饰方法

abstract

只能修饰类（包括内部类和外部类）和方法。

接口

接口代表一种标准。和类是同一级别的概念。

接口的特点

  1. 接口就是用来被实现的，实现类在实现接口时，必须实现接口中的所有抽象方法，或者这个实现类是一个抽象类。
  2. 一个类可以同时实现多个接口
  3. 接口不能直接创建对象
  4. 一个类可以同时继承父类，又实现接口，但是要求继承在前，实现在后
  5. 接口与接口之前支持多继承

接口的成员

JDK 1.8 之前：

  1. 全局的静态的常量，public static final
  2. 公共的抽象的方法。public abstract
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
package com.atguigu.exec1;

public class TestDefineAndUserInterface {
	
}

interface Flyable{
	int MAX_VALUE = 790000;  // 全局的静态的常量，public static final
	int MIN_VALUE = 0;       // 全局的静态的常量，public static final
	void fly();              // 公共的抽象的方法。public abstract
}

interface Jumpable{
	void jump();
}

class Animal{};

/**
 * 接口既继承类 Animal， 又实现 Flyable, Jumpable 两个接口
 * @author rex
 *
 */
class Bird extends Animal implements Flyable, Jumpable{

	@Override
	public void fly() {
		System.out.println("飞");
	}

	@Override
	public void jump() {
		System.out.println("跳");
	}

}

interface A{
	void a();
}

interface B{
	void b();
}

/**
 * 接口间的多继承
 * @author rex
 *
 */
interface C extends A, B{
	void c();
}

class D implements C{
	@Override
	public void a() {
		
	}
	@Override
	public void b() {
		
	}
	@Override
	public void c() {
		
	}
}

Comparable

Comparable 是 java.lang 下的一个接口，一个类要是实现了 Comparable 中的 compareTo 方法，那么这个类的实例之间就能进行比较。

Student 类

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
package com.atguigu.exec1;

public class Student implements Comparable{
	private String name;
	private int score;
	
	public Student(String name, int score) {
		super();
		this.name = name;
		this.score = score;
	}

	public Student() {
		super();
	}

	public String getName() {
		return name;
	}

	public void setName(String name) {
		this.name = name;
	}

	public int getScore() {
		return score;
	}

	public void setScore(int score) {
		this.score = score;
	}

	@Override
	public String toString() {
		return "Student [name=" + name + ", score=" + score + "]";
	}
	
	@Override
	public int compareTo(Object o) {
		if (!(o instanceof Student)) {
			System.out.println("抛出异常");

		}
		
		Student student = (Student) o;
		if(this.score > student.score){
			return 1;
		}else if (this.score < student.score) {
			return -1;
		}else {
			return 0;
		}
	}
}

TestStudent 类

1
2
3
4
5
6
7
8
9
10
package com.atguigu.exec1;

public class TestStudent {
	public static void main(String[] args) {
		Student s1 = new Student("张三", 90);
		Student s2 = new Student("李四", 80);
		
		System.out.println(s1.compareTo(s2));
	}
}